home *** CD-ROM | disk | FTP | other *** search
/ Stone Design / Stone Design.iso / Stone_Friends / Wave / WavesWorld / Source / IBPalettes / WWTCLKit / WWProcView.m < prev    next >
Encoding:
Text File  |  1995-03-22  |  14.8 KB  |  559 lines
  1.  
  2. #import "WWTCLInterp.h"
  3. #import "WWVarView.h"
  4. #import <ctype.h>
  5.  
  6. @implementation WWVarView
  7.  
  8. // the idea here is that this view has a tcl variable name associated
  9. // with it.  When a corresponding WWVarValueView is dragged over it,
  10. // it accepts the drag, sets its image to the contents of the
  11. // WWVarValueView and sets the value of it's tcl variable to the
  12.  
  13. + initialize { [WWVarView setVersion:3]; return self; }
  14.  
  15.  
  16. - initFrame:(const NXRect *)frameRect
  17. {
  18.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  19.  
  20.  
  21.    [super initFrame:frameRect];
  22.    [self registerForDraggedTypes:dragTypes count:1];
  23.  
  24.    tclVarNameSize = 32;
  25.    tclVarName = (char *)NXZoneCalloc([self zone], tclVarNameSize, sizeof(char));
  26.    tclVarValueSize = 32;
  27.    tclVarValue = (char *)NXZoneCalloc([self zone], tclVarValueSize, sizeof(char));
  28.    tclVarTypeSize = 32;
  29.    tclVarType = (char *)NXZoneCalloc([self zone], tclVarTypeSize, sizeof(char));
  30.    // <null pointer> is around 15 characters, so add (say) 40 bytes to cmdBuf...
  31.    cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  32.    framed = NO;
  33.    restrictDropToSameName = NO;
  34.    restrictDropToSameType = NO;
  35.    actAsSource = YES;
  36.    actAsSink = YES;
  37.    frameColor = NX_COLORBLACK;
  38.    frameWidth = 3.0;
  39.    nameSwitchView = nil;
  40.    valueSwitchView = nil;
  41.    typeSwitchView = nil;
  42.  
  43.    return self;
  44. }
  45.  
  46. - awake
  47. {
  48.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  49.  
  50.  
  51.    [super awake];
  52.    [self registerForDraggedTypes:dragTypes count:1];
  53.  
  54.    framed = NO;
  55.    cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  56.    
  57.    return self;
  58. }
  59.  
  60. - free
  61. {
  62.    const char *fileType[] = { "" };
  63.    Pasteboard *pboard = [Pasteboard newName:NXDragPboard];
  64.  
  65.  
  66.    [pboard declareTypes:fileType num:0 owner:nil];
  67.    [self unregisterDraggedTypes];
  68.    image = nil; // don't free the potentially shared image
  69.    if (tclVarName) { free(tclVarName); }
  70.    if (tclVarValue) { free(tclVarValue); }
  71.    if (tclVarType) { free(tclVarType); }
  72.    if (cmdBuf) { NXZoneFree([self zone], cmdBuf); }
  73.  
  74.    return [super free];
  75. }
  76.  
  77. - reinitializeStringsFromZone:(NXZone *)zone
  78. {
  79.   tclVarName = (char *)NXZoneCalloc(zone, tclVarNameSize, sizeof(char));
  80.   tclVarValue = (char *)NXZoneCalloc(zone, tclVarValueSize, sizeof(char));
  81.   tclVarType = (char *)NXZoneCalloc(zone, tclVarTypeSize, sizeof(char));
  82.   cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  83.   return self;
  84. }
  85.  
  86. - copyFromZone:(NXZone *)zone
  87. {
  88.   id newCopy = [super copyFromZone:zone];
  89.  
  90.   [newCopy reinitializeStringsFromZone:zone];
  91.   [newCopy setTclVarName:tclVarName];
  92.   [newCopy setTclVarValue:tclVarValue];
  93.   [newCopy setTclVarType:tclVarType];
  94.  
  95.   return newCopy;
  96. }
  97.  
  98. - drawSelf:(const NXRect *)rects :(int)num
  99. {
  100.   [super drawSelf:rects :num];
  101.   if (framed)
  102.   {  NXSetColor(frameColor);
  103.      NXFrameRectWithWidth(&bounds, (NXCoord)frameWidth);
  104.   }
  105.   return self;
  106. }
  107.  
  108. /*-------------------- methods to be the source of a dragging operation */
  109.  
  110. - mouseDown:(NXEvent *)theEvent
  111. {
  112.    NXPoint  zero = {0.0, 0.0};
  113.    id       thePboard;
  114.    const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  115.    static char *fooBarBaz = "fooBarBaz";
  116.  
  117.     
  118.    if (!image) { return self; }
  119.    if (!actAsSource) { return self; }
  120.  
  121.    // Prevent default window ordering (this is a new appkit feature)
  122.    [NXApp preventWindowOrdering];
  123.  
  124.    //get the Pboard
  125.    thePboard = [Pasteboard newName:NXDragPboard];
  126.    [thePboard declareTypes:dragTypes num:1 owner:nil];
  127.  
  128.    // we're not really going to use this info, we're just sticking something on the board...
  129.    [thePboard writeType:NXAsciiPboardType data:fooBarBaz length:(1 + strlen(fooBarBaz))];
  130.     
  131.    //start the drag
  132.    [self dragImage:image    // visible on screen during drag
  133.                 at:&zero    // offset the mouse point for the drag
  134.             offset:&zero    // offset the inital mouse pt
  135.              event:theEvent    // theEvent structure
  136.         pasteboard:thePboard    // a Pasteboard with data on it
  137.             source:self        // source object
  138.          slideBack:YES];    // if no destination animate back to source
  139.     
  140.     return self;
  141. }
  142.  
  143. - draggedImage:(NXImage *)image beganAt:(NXPoint *)screenPoint  { return self; }
  144.  
  145. - (NXDragOperation)draggingSourceOperationMaskForLocal:(BOOL)flag  { return (NX_DragOperationCopy | NX_DragOperationGeneric); }
  146.  
  147. - draggedImage:(NXImage *)image endedAt:(NXPoint *)screenPoint deposited:(BOOL)flag { return self; }
  148.  
  149. /*-------------------- methods to be the destination of a dragging operation */
  150.  
  151. - (NXDragOperation)draggingEntered:sender
  152. {
  153.    if (!actAsSink)
  154.    {  if (framed)
  155.       {  framed = NO;
  156.      [self display];
  157.       }
  158.       return NX_DragOperationNone;
  159.    }
  160.  
  161.    // check to make sure we are not the source and this operation is a copy
  162.    if (   ([sender draggingSourceOperationMask] & NX_DragOperationCopy) 
  163.        && ([sender draggingSource] != self)
  164.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  165.    {  
  166.       // if we're selective, need to check the var's name
  167.       // if it's not the same as ours, we're outta here
  168.       if (restrictDropToSameName)
  169.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  170.          {  if (framed)
  171.         {  framed = NO;
  172.            [self display];
  173.          }
  174.             return NX_DragOperationNone;
  175.      }
  176.       }
  177.       if (restrictDropToSameType)
  178.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  179.          {  if (framed)
  180.         {  framed = NO;
  181.            [self display];
  182.          }
  183.             return NX_DragOperationNone;
  184.      }
  185.       }
  186.       framed = YES;
  187.       [self display];
  188.       //return the type of operation we want to do, this will dictate
  189.       //the type of cursor will show up when accepting the drag
  190.       return NX_DragOperationCopy;
  191.    }
  192.    if (framed) 
  193.    {  framed = NO;
  194.       [self display];
  195.    }
  196.    return NX_DragOperationNone;
  197. }
  198.  
  199. - (NXDragOperation)draggingUpdated:sender
  200. {
  201.    if (!actAsSink)
  202.    {  if (framed)
  203.       {  framed = NO;
  204.      [self display];
  205.       }
  206.       return NX_DragOperationNone;
  207.    }
  208.  
  209.    // make sure that this is a copy operation, and that this instance
  210.    // of DragView is not the source
  211.    if (   ([sender draggingSourceOperationMask] & NX_DragOperationCopy) 
  212.        && ([sender draggingSource] != self)
  213.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  214.     { 
  215.       if (restrictDropToSameName)
  216.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  217.          {  if (framed)
  218.         {  framed = NO;
  219.            [self display];
  220.          }
  221.             return NX_DragOperationNone;
  222.      }
  223.       }
  224.       if (restrictDropToSameType)
  225.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  226.          {  if (framed)
  227.         {  framed = NO;
  228.            [self display];
  229.          }
  230.             return NX_DragOperationNone;
  231.      }
  232.       }
  233.       framed = YES;
  234.       [self display];
  235.       return NX_DragOperationCopy;
  236.    }
  237.    if (framed) 
  238.    {  framed = NO;
  239.       [self display];
  240.    }
  241.    return NX_DragOperationNone;
  242. }
  243.  
  244. - draggingExited:sender
  245. {
  246.    if (!actAsSink)
  247.    {  if (framed)
  248.       {  framed = NO;
  249.      [self display];
  250.       }
  251.       return NX_DragOperationNone;
  252.    }
  253.  
  254.    if (framed) 
  255.    {  framed = NO;
  256.       [self display];
  257.    }
  258.    return self;
  259. }
  260.  
  261. - (BOOL)prepareForDragOperation:sender  
  262. {  
  263.    if (!actAsSink)
  264.    {  if (framed)
  265.       {  framed = NO;
  266.      [self display];
  267.       }
  268.       return NO;
  269.    }
  270.    return YES; 
  271. }
  272.  
  273. static int notJustBlanks(const char *str)
  274. {
  275.   const char  *ptr;
  276.  
  277.  
  278.   ptr = str;
  279.   if (ptr)
  280.   {  while (*ptr && isspace(*ptr))
  281.      {  ptr++;
  282.      }
  283.      if (*ptr) // if we're not at the end and we stopped, it's not just blanks...
  284.      {  return 1;
  285.      }
  286.   }
  287.   return 0;
  288. }
  289.  
  290.  
  291. - (BOOL)performDragOperation:sender
  292. {
  293.    if (!actAsSink)
  294.    {  if (framed)
  295.       {  framed = NO;
  296.      [self display];
  297.       }
  298.       return NO;
  299.    }
  300.  
  301.    // make sure that what we are getting is from the same application
  302.    // and did not originate from this view.
  303.    if (   [sender isDraggingSourceLocal] 
  304.        && ([sender draggingSource] != self) 
  305.        && ([[sender draggingSource] respondsTo:@selector(tclVarValue)]))
  306.  
  307.    {  // should check to make sure the sender will respond appropriately...
  308.       if (restrictDropToSameName)
  309.       {  if (tclVarName && [[sender draggingSource] tclVarName] && strcmp(tclVarName, [[sender draggingSource] tclVarName]))
  310.          {  if (framed) 
  311.         {  framed = NO;
  312.            [self display];
  313.         }
  314.         return NO;
  315.      }
  316.       }
  317.       if (restrictDropToSameType)
  318.       {  if (tclVarType && [[sender draggingSource] tclVarType] && strcmp(tclVarType, [[sender draggingSource] tclVarType]))
  319.          {  if (framed) 
  320.             {  framed = NO;
  321.            [self display];
  322.         }
  323.         return NO;
  324.      }
  325.       }
  326.       [self setImage:nil];
  327.       [self setImage:[[sender draggingSource] image]];
  328.       [self setTclVarValue:[[sender draggingSource] tclVarValue]];
  329.       if (nameSwitchView)
  330.       {  //[nameSwitchView showViewNamed:tclVarName];
  331.       }
  332.       if (typeSwitchView)
  333.       {  //[typeSwitchView showViewNamed:tclVarType];
  334.       }
  335.       if (notJustBlanks(tclVarValue))
  336.       {  // cmdBuf is basically "set <tclVarName> <tclVarValue>"
  337.          if (valueSwitchView)
  338.          {  //[valueSwitchView showViewNamed:tclVarValue];
  339.          }
  340.          sprintf(cmdBuf, "set %s %s", tclVarName, tclVarValue);
  341.          [interp globalEval:cmdBuf];
  342.       }
  343.       framed = NO;
  344.       [self display];
  345.    }
  346.    if (framed) 
  347.    {  framed = NO;
  348.       [self display];
  349.    }
  350.    return YES;
  351. }
  352.  
  353. - concludeDragOperation:sender {  return self; }
  354.  
  355. /*-------------------- methods to display, and other useful stuff */
  356.  
  357. - (BOOL)acceptsFirstMouse  {  return YES; }
  358.  
  359. - (BOOL)shouldDelayWindowOrderingForEvent:(NXEvent *)theEvent {  return YES; }
  360.  
  361. // set and get stuff
  362.  
  363. - setTclVarValue:(const char *)str 
  364. { 
  365.   int   cnt;
  366.  
  367.  
  368.   if (tclVarValueSize <= 0) 
  369.   {  tclVarValueSize = 32; 
  370.      tclVarValue = (char *)NXZoneCalloc([self zone], tclVarValueSize, sizeof(char));
  371.      cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  372.   }
  373.   cnt = strlen(str);
  374.   while (cnt >= tclVarValueSize)
  375.   {  tclVarValueSize *= 2;
  376.      tclVarValue = (char *)NXZoneRealloc([self zone], tclVarValue, tclVarValueSize);
  377.   }
  378.   cmdBuf = (char *)NXZoneRealloc([self zone], cmdBuf, (40 + tclVarNameSize + tclVarValueSize));
  379.   strcpy(tclVarValue, str); 
  380.   return self; 
  381. }
  382. //
  383. - (const char *)tclVarValue { return tclVarValue; }
  384.  
  385.  
  386. - setTclVarName:(const char *)str 
  387. { 
  388.   int   cnt;
  389.  
  390.  
  391.   if (tclVarNameSize <= 0) 
  392.   {  tclVarNameSize = 32; 
  393.      tclVarName = (char *)NXZoneCalloc([self zone], tclVarNameSize, sizeof(char));
  394.      cmdBuf = (char *)NXZoneCalloc([self zone], (40 + tclVarNameSize + tclVarValueSize), sizeof(char));
  395.   }
  396.   cnt = strlen(str);
  397.   while (cnt >= tclVarNameSize)
  398.   {  tclVarNameSize *= 2;
  399.      tclVarName = (char *)NXZoneRealloc([self zone], tclVarName, tclVarNameSize);
  400.   }
  401.   cmdBuf = (char *)NXZoneRealloc([self zone], cmdBuf, (40 + tclVarNameSize + tclVarValueSize));
  402.   strcpy(tclVarName, str); 
  403.   return self; 
  404. }
  405. //
  406. - (const char *)tclVarName { return tclVarName; }
  407.  
  408. - setTclVarType:(const char *)str 
  409. { 
  410.   int   cnt;
  411.  
  412.  
  413.   if (tclVarTypeSize <= 0) 
  414.   {  tclVarTypeSize = 32; 
  415.      tclVarType = (char *)NXZoneCalloc([self zone], tclVarTypeSize, sizeof(char));
  416.   }
  417.   cnt = strlen(str);
  418.   while (cnt >= tclVarTypeSize)
  419.   {  tclVarTypeSize *= 2;
  420.      tclVarType = (char *)NXZoneRealloc([self zone], tclVarType, tclVarTypeSize);
  421.   }
  422.   strcpy(tclVarType, str); 
  423.   return self; 
  424. }
  425. //
  426. - (const char *)tclVarType { return tclVarType; }
  427.  
  428.  
  429. - (BOOL)restrictDropToSameName { return restrictDropToSameName; }
  430. - setRestrictDropToSameName:(BOOL)flag {  restrictDropToSameName = flag; return self; }
  431.  
  432. - (BOOL)restrictDropToSameType { return restrictDropToSameType; }
  433. - setRestrictDropToSameType:(BOOL)flag {  restrictDropToSameType = flag; return self; }
  434.  
  435. - (BOOL)actAsSink { return actAsSink; }
  436. - setActAsSink:(BOOL)flag 
  437. {  if (actAsSink && !flag) // we're about to turn it off...
  438.    {  [self unregisterDraggedTypes];
  439.    }
  440.    if (!actAsSink && flag) // we're about to turn it on...
  441.    {  const char  *dragTypes[] = { NXAsciiPboardType, NULL};
  442.       [self registerForDraggedTypes:dragTypes count:1];
  443.    }
  444.    
  445.    actAsSink = flag; 
  446.    return self; 
  447. }
  448.  
  449. - (BOOL)actAsSource { return actAsSource; }
  450. - setActAsSource:(BOOL)flag {  actAsSource = flag; return self; }
  451.  
  452. // IB stuff
  453. - (const char *)getInspectorClassName 
  454. {  
  455.    NXEvent  *event = [NXApp currentEvent];
  456.  
  457.    if (event->flags & NX_ALTERNATEMASK)
  458.    {  return [super getInspectorClassName];
  459.    }
  460.    
  461.    return "WWVarViewIBInspector"; 
  462. }
  463.  
  464. - write:(NXTypedStream *)stream 
  465. {
  466.    [super write:stream];
  467.    NXWriteTypes(stream, "***cccfc", &tclVarName, &tclVarValue, &tclVarType, 
  468.         &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth, &actAsSink);
  469.    NXWriteColor(stream, frameColor);
  470.    return self;
  471. }
  472. //
  473. - read:(NXTypedStream *)stream 
  474. {
  475.    int version;
  476.  
  477.    [super read:stream];
  478.  
  479.    version = NXTypedStreamClassVersion(stream, "WWVarView");
  480.    if (version == 1)
  481.    {  NXReadTypes(stream, "***ccc", 
  482.           &tclVarName, &tclVarValue, &tclVarType, 
  483.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource);
  484.       frameColor = NX_COLORBLACK;
  485.       if (tclVarName)
  486.       {  tclVarNameSize = strlen(tclVarName) + 1;
  487.       }
  488.       else
  489.       {  tclVarNameSize = 0;
  490.       }
  491.       if (tclVarValue)
  492.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  493.       }
  494.       else
  495.       {  tclVarValueSize = 0;
  496.       }
  497.       if (tclVarType)
  498.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  499.       }
  500.       else
  501.       {  tclVarTypeSize = 0;
  502.       }
  503.    }
  504.    if (version == 2)
  505.    {  NXReadTypes(stream, "***cccf", 
  506.           &tclVarName, &tclVarValue, &tclVarType, 
  507.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth);
  508.       frameColor = NXReadColor(stream);
  509.  
  510.       if (tclVarName)
  511.       {  tclVarNameSize = strlen(tclVarName) + 1;
  512.       }
  513.       else
  514.       {  tclVarNameSize = 0;
  515.       }
  516.       if (tclVarValue)
  517.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  518.       }
  519.       else
  520.       {  tclVarValueSize = 0;
  521.       }
  522.       if (tclVarType)
  523.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  524.       }
  525.       else
  526.       {  tclVarTypeSize = 0;
  527.       }
  528.    }
  529.    if (version == 3)
  530.    {  NXReadTypes(stream, "***cccfc", 
  531.           &tclVarName, &tclVarValue, &tclVarType, 
  532.           &restrictDropToSameName, &restrictDropToSameType, &actAsSource, &frameWidth, &actAsSink);
  533.       frameColor = NXReadColor(stream);
  534.  
  535.       if (tclVarName)
  536.       {  tclVarNameSize = strlen(tclVarName) + 1;
  537.       }
  538.       else
  539.       {  tclVarNameSize = 0;
  540.       }
  541.       if (tclVarValue)
  542.       {  tclVarValueSize = strlen(tclVarValue) + 1;
  543.       }
  544.       else
  545.       {  tclVarValueSize = 0;
  546.       }
  547.       if (tclVarType)
  548.       {  tclVarTypeSize = strlen(tclVarType) + 1;
  549.       }
  550.       else
  551.       {  tclVarTypeSize = 0;
  552.       }
  553.    }
  554.    return self;
  555. }
  556.  
  557.  
  558. @end
  559.